/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Aleatorio;


/**
 *
  * @author Edison Xavier Espinosa Luna
 * @author Luis Alberto Flores Aguilar
 * @author Daniel Jimenez Gonzalez
 * @author Ana Maria Gonzalez Bustan
 * @author Tania Valarezo Cevallosl
 */

public class Algoritmo {
        public static int filas=3;
        public static int columnas=4;
       private static long iteracciones;
       long ti,tf;
          
    public int[][] generar(){ //Metodo para generar la matriz aleatoriamente 
                
        int matrizgenerada[][]=new int[filas][columnas];
        
        boolean bandera[]=new boolean[9];//arreglo booleano para verificar que no se repitan los muneroros aleatorios del 1-8
        int NumNoRep=0;

        for (int i = 0; i <filas; i++) {//llenar la matriz aleatoriamente sin repetirse por filas
            for (int j = 0; j < columnas; j++) {//llenar la matriz aleatoriamente sin repetirse por columnas
                if((i==0&&j==0)||(i==0&&j==3)||(i==2&&j==0)||(i==2&&j==3)){//condicion para llenar las esquinas de ceros
                    matrizgenerada[i][j]=0;//asigna las posiciones cero
                }else{
                    do{//hacer generar un numero aleatorio 
                        NumNoRep=(int)(Math.random()*8+1);
                    //}while(bandera[NumNoRep]);//mientras la matriz tenga numeros no repetidos o sea true en sus posiciones 
                    }while(bandera[NumNoRep]);
                    bandera[NumNoRep]=true;
                    
                    matrizgenerada[i][j]=NumNoRep;
                    
                }
           }
        }
        iteracciones++;
        
        return matrizgenerada;
     }
    
    public String toString (int[][] m){//Metodo para presentar la metriz
             
        String result="";
        for (int i = 0; i < filas; i++) {
            result+="|_";
            for (int j = 0; j < columnas; j++) {
                result+=m[i][j]+"_|_";
            }
            result+="\n";
        }
        return result;
    }
    
    public void comparacion(){//Metodo para comparar los numeros de la matriz que no sean consecutivos
        
        int matcompa[][] = new int[filas][columnas];
        
        matcompa=generar();//matriz que pide que se genere una nueva matriz a comparar
        
        int er = 0;
        ti=System.nanoTime();
        for (int i = 0; i < filas; i++) {//ciclo que compara el numero de la posicion(1,0) con los de la posicion (0,1),(1,1),(2,1)
            int num1=matcompa[1][0];
            int numCom2=matcompa[i][1];
            if(numCom2==num1-1||numCom2==num1+1){
                 er++;
            }      
        }
        for (int i = 0; i < filas; i++) {//ciclo que compara el numero de la posicion(1,3) con los de la posicion (0,2),(1,2),(2,2)
            int num2=matcompa[1][3];
            int numCom2=matcompa[i][2];
            if(numCom2==num2-1||numCom2==num2+1){
                 er++;
            }
        }                
        for (int i = 0; i < 1; i++) {//ciclo para comparar los del centro por numeros que ss especifica por partes en este ciclo
            int num3=matcompa[0][1];
            int numCom2=matcompa[1][1];
            int numCom3=matcompa[1][2];
            int numCom4=matcompa[0][2];
            if(numCom2==num3-1||numCom2==num3+1){//condiciones para comparar el numero de la posicion(0,1) con (1,1),(1,2),(0,2)
                er++;
            }else if(numCom3==num3-1||numCom3==num3+1){
                 er++;
            }else if(numCom4==num3-1||numCom4==num3+1){
                 er++;
            }
            //------------------------------------------------------------------
            int num4=matcompa[1][1];
            int numCom5=matcompa[2][1];
            int numCom6=matcompa[2][2];
            int numCom7=matcompa[1][2];
            int numCom0=matcompa[0][2];
            if((numCom5==num4-1||numCom5==num4+1)){//condiciones para comparar el numero de la posicion(1,1) con (2,1),(2,2),(1,2),(0,2)
                er++;
            }else if(numCom6==num4-1||numCom6==num4+1){
                er++;
            }else if(numCom7==num4-1||numCom7==num4+1){
                er++;
            }else if(numCom0==num4-1||numCom0==num4+1){
                er++;
            }
            //------------------------------------------------------------------
            int num5=matcompa[2][1];
            int numCom8=matcompa[2][2];
            int numCom9=matcompa[1][2];
            if((numCom8==num5-1||numCom8==num5+1)){//condiciones para comparar el numero de la posicion(2,1) con (2,2),(1,2)
                er++;
            }else if(numCom9==num5-1||numCom9==num5+1){
                er++;
            }
            //-----------------------------------------------------------------
            int num6=matcompa[2][2];
            int numCom10=matcompa[1][2];
            if(numCom10==num6-1||numCom10==num6+1){//condiciones para comparar el numero de la posicion(2,2) con (1,2)
                er++;
            }
            //------------------------------------------------------------------
            int num7=matcompa[1][2];
            int numCom11=matcompa[0][2];
  
            if((numCom11==num7-1||numCom11==num7+1)){//condiciones para comparar el numero de la posicion(1,2) con (0,2)
                er++;
            }
        }
            
        tf=System.nanoTime()-ti;//hasta aqui se calcula el tiempo en nanosegundos
        
        
        if(er==0){//condicion que verifica que si no se han generado errores de consecutividad en las comparaciones presenta la solucion
            //presentacion de resultados en caso correcto
            System.out.println(toString(matcompa));
            System.out.print("iteraccion: "+iteracciones);//presenta la interaccion generada
            System.out.println(" MATRIZ CORRECTA\t"+er+" errores");
            System.out.println("tiempo "+tf+" nanosegundos\t");
            
        }else{
            //presentacion de resultados en caso incorrecto solo por consola
                System.out.println(""+toString(matcompa)+"MATRIZ INCORRECTA\t"+er+" errores"+
                    "\ttiempo "+tf+" nanosegundos");
                if(iteracciones<5000){//contrl para generar matrices con un limite independiente que si genera o no la solucion
                    comparacion();//llamada del metodo hasta que encuentre la solucion correcta
                }
                
        }
       
    }
    
   public static void main(String []args)throws Exception{
        
            Algoritmo alg=new Algoritmo();
      
            alg.comparacion();
                 
    }
}
